﻿using NHibernate.Linq;
using System.Linq;
using System;
using System.Collections.Generic;

namespace IsoCompte.Classe
{
    #region UtilisateurRepository
    /// <summary>
    /// Classe permettant de Gérer l'accès aux données de la table Utilisateur
    /// </summary>
    public class UtilisateurRepository
    {
        /// <summary>
        /// Retrouve un Utilisateur d'après son Id
        /// </summary>
        /// <param name="id">Identifiant unique de l'utilisateur</param>
        /// <returns>Utilisateur</returns>
        public static Utilisateur GetById(int id)
        {
            Log.Logger.Debug("Debut GetById:" + id);
            Log.Logger.Info("Initialisation de l'objet Utilisateur");
            Utilisateur u = new Utilisateur();
            try
            {
                using (var session = NHibernateHelper.OpenSession())
                {
                    Log.Logger.Info("Récupération de l'Utilisateur");
                    u = (from utilisateur in session.Query<Utilisateur>()
                         where utilisateur.Id == id
                         select utilisateur).Single();
                }
            }
            catch (Exception ex)
            {
                Log.Logger.Error(ex);
                throw;
            }
            Log.Logger.Debug("Fin GetByid");
            return u;
        }
        /// <summary>
        /// Retrouve un Utilisateur d'après son Login
        /// </summary>
        /// <param name="login">Login unique de l'utilisateur</param>
        /// <returns>Utilisateur</returns>
        public static Utilisateur GetByLogin(string login)
        {
            Log.Logger.Debug("Debut GetByLogin:" + login);
            Log.Logger.Info("Initialisation de l'objet Utilisateur");
            Utilisateur u = new Utilisateur();
            try
            {
                using (var session = NHibernateHelper.OpenSession())
                {

                    u = (from utilisateur in session.Query<Utilisateur>()
                         where utilisateur.Login == login
                         select utilisateur).Single();
                }
            }
            catch (Exception ex)
            {
                Log.Logger.Error(ex);
                throw;
            }
            Log.Logger.Debug("Fin GetByLogin");
            return u;
        }
        /// <summary>
        /// Ajoute l'Utilisateur passé en paramétre
        /// </summary>
        /// <param name="u">L'Utilisateur à créer</param>
        /// <returns>L'Utilisateur créé</returns>
        public static Utilisateur Add(Utilisateur u)
        {
            Log.Logger.Debug("Debut Add");
            using (var session = NHibernateHelper.OpenSession())
            {
                using (var transaction = session.BeginTransaction())
                {
                    try
                    {
                        Log.Logger.Debug("Tentative de Save...");
                        session.Save(u);
                        Log.Logger.Debug("Save OK - Tentative de Commit...");
                        transaction.Commit();
                        Log.Logger.Debug("Commit OK");
                    }
                    catch (Exception ex)
                    {
                        Log.Logger.Error(ex);
                        Log.Logger.Debug("Tentative de Rollback...");
                        transaction.Rollback();
                        Log.Logger.Debug("Rollback OK");
                        throw;
                    }
                }
            }
            Log.Logger.Debug("Fin Add");
            return u;
        }
        /// <summary>
        /// Met à jour l'Utilisateur passé en paramétre
        /// </summary>
        /// <param name="u">L'Utilisateur à mettre à jour</param>
        /// <returns>L'Utilisateur mis à jour</returns>
        public static Utilisateur Update(Utilisateur u)
        {
            Log.Logger.Debug("Debut Update");
            using (var session = NHibernateHelper.OpenSession())
            {
                using (var transaction = session.BeginTransaction())
                {
                    try
                    {
                        Log.Logger.Debug("Tentive d'Update...");
                        session.Update(u);
                        Log.Logger.Debug("Update OK - Tentative de Commit...");
                        transaction.Commit();
                        Log.Logger.Debug("Commit OK");

                    }
                    catch(Exception ex)
                    {
                        Log.Logger.Error(ex);
                        Log.Logger.Debug("Tentative de Rollback...");
                        transaction.Rollback();
                        Log.Logger.Debug("Rollback OK");
                        throw;
                    }
                }
            }
            Log.Logger.Debug("Fin Update");
            return u;
        }
        /// <summary>
        /// Supprime l'Utilisateur passé en paramétre
        /// </summary>
        /// <param name="u">L'Utilisateur à supprimer</param>
        public static void Delete(Utilisateur u)
        {
            Log.Logger.Debug("Debut Delete");
            using (var session = NHibernateHelper.OpenSession())
            {
                using (var transaction = session.BeginTransaction())
                {
                    try
                    {
                        Log.Logger.Debug("Tentative de Delete...");
                        session.Delete(u);
                        Log.Logger.Debug("Delete OK - Tentative de Commit...");
                        transaction.Commit();
                        Log.Logger.Debug("Delete OK");
                    }
                    catch(Exception ex)
                    {
                        Log.Logger.Error(ex);
                        Log.Logger.Debug("Tentative de Rollback...");
                        transaction.Rollback();
                        Log.Logger.Debug("Rollback OK");
                        throw;
                    }
                }
            }
            Log.Logger.Debug("Fin Delete");
        }
    }
    #endregion

    #region CompteRepository
    /// <summary>
    /// Classe permettant de Gérer l'accès aux données de la table Comptes
    /// </summary>
    public class CompteRepository
    {
        /// <summary>
        /// Retrouve un Compte d'après son Id
        /// </summary>
        /// <param name="id">Identifiant unique du compte</param>
        /// <returns>Compte</returns>
        public static Compte GetById(int id)
        {
            Log.Logger.Debug("Debut BetBydId:" + id);
            Log.Logger.Info("Initialisation du Compte");
            Compte c = new Compte();
            using (var session = NHibernateHelper.OpenSession())
            {
                Log.Logger.Info("Récupération des informations du Compte");
                c = (from compte in session.Query<Compte>()
                     where compte.Id == id
                     select compte).Single();
            }
            Log.Logger.Debug("Fin GetByid");
            return c;
        }
        /// <summary>
        /// Ajoute le Compte passé en paramétre
        /// </summary>
        /// <param name="c">Le Compte à créer</param>
        /// <returns>Le Compte créé</returns>
        public static Compte Add(Compte c)
        {
            Log.Logger.Debug("Debut Add");
            using (var session = NHibernateHelper.OpenSession())
            {
                using (var transaction = session.BeginTransaction())
                {
                    try
                    {
                        Log.Logger.Debug("Tentative de Save...");
                        session.Save(c);
                        Log.Logger.Debug("Save OK - Tentative de Commit...");
                        transaction.Commit();
                        Log.Logger.Debug("Commit OK");
                    }
                    catch(Exception ex)
                    {
                        Log.Logger.Error(ex);
                        Log.Logger.Debug("Tentative de Rollback...");
                        transaction.Rollback();
                        Log.Logger.Debug("Rollback OK");
                        throw;
                    }
                }
            }
            Log.Logger.Debug("Fin Add");
            return c;
        }
        /// <summary>
        /// Met à jour le Compte passé en paramétre
        /// </summary>
        /// <param name="c">Le Compte à mettre à jour</param>
        /// <returns>Le Compte mis à jour</returns>
        public static Compte Update(Compte c)
        {
            Log.Logger.Debug("Debut Update");
            using (var session = NHibernateHelper.OpenSession())
            {
                using (var transaction = session.BeginTransaction())
                {
                    try
                    {
                        Log.Logger.Debug("Tentative d'Update...");
                        session.Update(c);
                        Log.Logger.Debug("Update OK - Tentative de Commit...");
                        transaction.Commit();
                        Log.Logger.Debug("Commit OK");
                    }
                    catch(Exception ex)
                    {
                        Log.Logger.Error(ex);
                        Log.Logger.Debug("Tentative de Rollback...");
                        transaction.Rollback();
                        Log.Logger.Debug("Rollback OK");
                        throw;
                    }
                }
                Log.Logger.Debug("Fin Update");
            }
            return c;
        }
        /// <summary>
        /// Supprime le Compte passé en paramétre
        /// </summary>
        /// <param name="c">Le Compte à supprimer</param>
        public static void Delete(Compte c)
        {
            Log.Logger.Debug("Debut Delete");
            using (var session = NHibernateHelper.OpenSession())
            {
                using (var transaction = session.BeginTransaction())
                {
                    try
                    {
                        Log.Logger.Debug("Tentative de Delete...");
                        session.Delete(c);
                        Log.Logger.Debug("Delete OK - Tentative de Commit...");
                        transaction.Commit();
                        Log.Logger.Debug("Commit OK");
                    }
                    catch(Exception ex)
                    {
                        Log.Logger.Error(ex);
                        Log.Logger.Debug("Tentative de Rollback...");
                        transaction.Rollback();
                        Log.Logger.Debug("Rollback OK");
                        throw;
                    }
                }
            }
            Log.Logger.Debug("Fin Delete");
        }
        /// <summary>
        /// Retrouve la liste des Compte d'un Utilisateur passé en paramètre
        /// </summary>
        /// <param name="u">Utilisateur possédant les comptes</param>
        /// <returns>La liste des Compte</returns>
        public static IList<Compte> GetByUtilisateur(Utilisateur u)
        {
            Log.Logger.Debug("Debut GetByUtilisateur:" + u.Id);
            IList<Compte> lc;
            using (var session = NHibernateHelper.OpenSession())
            {
                Log.Logger.Info("Récupérationde la liste");
                lc = (from compte in session.Query<Compte>()
                      where compte.Utilisateur == u
                      select compte).ToList();
                Log.Logger.Info("La liste contient " + lc.Count() + " comptes");
            }
            Log.Logger.Debug("Fin GetByUtilisateur");
            return lc;
        }
    }
    #endregion

    #region CategorieRepository
    /// <summary>
    /// Classe permettant de Gérer l'accès aux données de la table Categorie
    /// </summary>
    public class CategorieRepository
    {
        /// <summary>
        /// Retrouve une Categorie d'après son Id
        /// </summary>
        /// <param name="id">Identifiant unique de la Categorie</param>
        /// <returns>Categorie</returns>
        public static Categorie GetById(int id)
        {
            Log.Logger.Debug("Debut GetById:" + id);
            Log.Logger.Info("Initialisation de la Categorie");
            Categorie c = new Categorie();
            using (var session = NHibernateHelper.OpenSession())
            {
                Log.Logger.Info("Récupération de la Categorie");
                c = (from categorie in session.Query<Categorie>()
                     where categorie.Id == id
                     select categorie).Single();
            }
            Log.Logger.Debug("Fin BetById");
            return c;
        }
        /// <summary>
        /// Ajoute la Categorie passée en paramétre
        /// </summary>
        /// <param name="c">La Categorie à créer</param>
        /// <returns>La Categorie créée</returns>
        public static Categorie Add(Categorie c)
        {
            Log.Logger.Debug("Debut Add");
            using (var session = NHibernateHelper.OpenSession())
            {
                using (var transaction = session.BeginTransaction())
                {
                    try
                    {
                        Log.Logger.Info("Tentative de Save");
                        session.Save(c);
                        Log.Logger.Info("Save OK - Tentative de Commit");
                        transaction.Commit();
                        Log.Logger.Info("Commit OK");
                    }
                    catch(Exception ex)
                    {
                        Log.Logger.Error(ex);
                        Log.Logger.Info("Tentative de Rollback...");
                        transaction.Rollback();
                        Log.Logger.Info("Rollback OK");
                        throw;
                    }
                }
            }
            Log.Logger.Debug("Fin Add");
            return c;
        }
        /// <summary>
        /// Met à jour la Caegorie passée en paramétre
        /// </summary>
        /// <param name="c">La Categorie à mettre à jour</param>
        /// <returns>La Categorie mis à jour</returns>
        public static Categorie Update(Categorie c)
        {
            Log.Logger.Debug("Debut Update");
            using (var session = NHibernateHelper.OpenSession())
            {
                using (var transaction = session.BeginTransaction())
                {
                    try
                    {
                        Log.Logger.Debug("Tentative d'Update...");
                        session.Update(c);
                        Log.Logger.Debug("Update OK - Tentative de Commit...");
                        transaction.Commit();
                        Log.Logger.Debug("Commit OK");
                    }
                    catch(Exception ex)
                    {
                        Log.Logger.Debug(ex);
                        Log.Logger.Debug("Tentative de Rollback...");
                        transaction.Rollback();
                        Log.Logger.Debug("Rollback OK");
                        throw;
                    }
                }
            }
            Log.Logger.Debug("Fin Update");
            return c;
        }
        /// <summary>
        /// Supprime la Categorie passée en paramétre
        /// </summary>
        /// <param name="c">La Categorie à supprimer</param>
        public static void Delete(Categorie c)
        {
            Log.Logger.Debug("Debut Delete");
            using (var session = NHibernateHelper.OpenSession())
            {
                using (var transaction = session.BeginTransaction())
                {
                    try
                    {
                        Log.Logger.Debug("Tentative de Delete...");
                        session.Delete(c);
                        Log.Logger.Debug("Delete OK - Tentative de Commit...");
                        transaction.Commit();
                        Log.Logger.Debug("Commit OK");
                    }
                    catch(Exception ex)
                    {
                        Log.Logger.Debug(ex);
                        Log.Logger.Debug("Tentative de Rollback...");
                        transaction.Rollback();
                        Log.Logger.Debug("Rollback OK");
                        throw;
                    }
                }
            }
            Log.Logger.Debug("Delete Fin");
        }
        /// <summary>
        /// Retrouve la liste des Sous-Categorie d'une Categorie passée en paramètre
        /// </summary>
        /// <param name="c">Categorie Parent</param>
        /// <returns>La liste des Sous-Categorie</returns>
        public static IList<Categorie> GetSousCategorie(Categorie c)
        {
            Log.Logger.Debug("Debut GetSousCategorie");
            IList<Categorie> lc;
            using (var session = NHibernateHelper.OpenSession())
            {
                Log.Logger.Debug("Récupération de la liste");
                lc = (from categorie in session.Query<Categorie>()
                      where categorie.CategorieParent == c
                      select categorie).ToList();
                Log.Logger.Debug("La liste contient " + lc.Count() + " éléments");
            }
            Log.Logger.Debug("Fin GetSousCategorie");
            return lc;
        }
    }
    #endregion

    #region ModePaiementRepository
    /// <summary>
    /// Classe permettant de gérer l'accès aux données de la table ModePaiements
    /// </summary>
    public class ModePaiementRepository
    {
        /// <summary>
        /// Retrouve un ModePaiement d'après son Id
        /// </summary>
        /// <param name="id">Identifiant unique du ModePaiement</param>
        /// <returns>ModePaiement</returns>
        public static ModePaiement GetById(int id)
        {
            Log.Logger.Debug("Debut GetById:" + id);
            Log.Logger.Info("Initialisation du ModePaiement");
            ModePaiement mp = new ModePaiement();
            using (var session = NHibernateHelper.OpenSession())
            {
                Log.Logger.Info("Récupération du ModePaiement");
                mp = (from categorie in session.Query<ModePaiement>()
                     where categorie.Id == id
                     select categorie).Single();
            }
            Log.Logger.Debug("Fin BetById");
            return mp;
        }
        /// <summary>
        /// Ajoute le ModePaiement passé en paramétre
        /// </summary>
        /// <param name="mp">Le ModePaiement à créer</param>
        /// <returns>Le ModePaiement créé</returns>
        public static ModePaiement Add(ModePaiement mp)
        {
            Log.Logger.Debug("Debut Add");
            using (var session = NHibernateHelper.OpenSession())
            {
                using (var transaction = session.BeginTransaction())
                {
                    Log.Logger.Info("Tentative de Save");
                    try
                    {
                        Log.Logger.Info("Save OK - Tentative de Commit");
                        session.Save(mp);
                        Log.Logger.Info("Save OK - Tentative de Commit");
                        transaction.Commit();
                        Log.Logger.Info("Commit OK");
                    }
                    catch (Exception ex)
                    {
                        Log.Logger.Error(ex);
                        Log.Logger.Info("Tentative de Rollback...");
                        transaction.Rollback();
                        Log.Logger.Info("Rollback OK");
                        throw;
                    }
                }
            }
            Log.Logger.Debug("Fin Add");
            return mp;
        }
        /// <summary>
        /// Met à jour le ModePaiement passé en paramétre
        /// </summary>
        /// <param name="mp">Le ModePaiement à mettre à jour</param>
        /// <returns>Le ModePaiement mis à jour</returns>
        public static ModePaiement Update(ModePaiement mp)
        {
            Log.Logger.Debug("Debut Update");
            using (var session = NHibernateHelper.OpenSession())
            {
                using (var transaction = session.BeginTransaction())
                {
                    try
                    {
                        Log.Logger.Debug("Tentative d'Update...");
                        session.Update(mp);
                        Log.Logger.Debug("Update OK - Tentative de Commit...");
                        transaction.Commit();
                        Log.Logger.Debug("Commit OK");
                    }
                    catch (Exception ex)
                    {
                        Log.Logger.Debug(ex);
                        Log.Logger.Debug("Tentative de Rollback...");
                        transaction.Rollback();
                        Log.Logger.Debug("Rollback OK");
                        throw;
                    }
                }
            }
            Log.Logger.Debug("Fin Update");
            return mp;
        }
        /// <summary>
        /// Supprime le ModePaiement passé en paramétre
        /// </summary>
        /// <param name="mp">Le ModePaiement à supprimer</param>
        public static void Delete(ModePaiement mp)
        {
            Log.Logger.Debug("Debut Delete");
            using (var session = NHibernateHelper.OpenSession())
            {
                using (var transaction = session.BeginTransaction())
                {
                    try
                    {
                        Log.Logger.Debug("Tentative de Delete...");
                        session.Delete(mp);
                        Log.Logger.Debug("Delete OK - Tentative de Commit...");
                        transaction.Commit();
                        Log.Logger.Debug("Commit OK");
                    }
                    catch (Exception ex)
                    {
                        Log.Logger.Debug(ex);
                        Log.Logger.Debug("Tentative de Rollback...");
                        transaction.Rollback();
                        Log.Logger.Debug("Rollback OK");
                        throw;
                    }
                }
            }
            Log.Logger.Debug("Delete Fin");
        }
    }
    #endregion

    #region OperationRepository
    /// <summary>
    /// Classe permettant de gérer l'accès aux données de la table Operations
    /// </summary>
    public class OperationRepository
    {
        /// <summary>
        /// Retrouve une Operation d'après son Id
        /// </summary>
        /// <param name="id">Identifiant unique de l'Operation</param>
        /// <returns>Operation</returns>
        public static Operation GetById(int id)
        {
            Log.Logger.Debug("Debut GetById:" + id);
            Log.Logger.Info("Initialisation de l'Operation");
            Operation o = new Operation();
            using (var session = NHibernateHelper.OpenSession())
            {
                Log.Logger.Info("Récupération du Operation");
                o = (from operation in session.Query<Operation>()
                     where operation.Id == id
                     select operation).Single();
            }
            Log.Logger.Debug("Fin BetById");
            return o;
        }
        /// <summary>
        /// Ajoute l'Operation passée en paramétre
        /// </summary>
        /// <param name="o">L'Operation à créer</param>
        /// <returns>L'Operation créée</returns>
        public static Operation Add(Operation o)
        {
            Log.Logger.Debug("Debut Add");
            using (var session = NHibernateHelper.OpenSession())
            {
                using (var transaction = session.BeginTransaction())
                {
                    Log.Logger.Info("Tentative de Save");
                    try
                    {
                        Log.Logger.Info("Save OK - Tentative de Commit");
                        session.Save(o);
                        Log.Logger.Info("Save OK - Tentative de Commit");
                        transaction.Commit();
                        Log.Logger.Info("Commit OK");
                    }
                    catch (Exception ex)
                    {
                        Log.Logger.Error(ex);
                        Log.Logger.Info("Tentative de Rollback...");
                        transaction.Rollback();
                        Log.Logger.Info("Rollback OK");
                        throw;
                    }
                }
            }
            Log.Logger.Debug("Fin Add");
            return o;
        }
        /// <summary>
        /// Met à jour l'Operation passée en paramétre
        /// </summary>
        /// <param name="o">L'Operation à mettre à jour</param>
        /// <returns>L'Operation mise à jour</returns>
        public static Operation Update(Operation o)
        {
            Log.Logger.Debug("Debut Update");
            using (var session = NHibernateHelper.OpenSession())
            {
                using (var transaction = session.BeginTransaction())
                {
                    try
                    {
                        Log.Logger.Debug("Tentative d'Update...");
                        session.Update(o);
                        Log.Logger.Debug("Update OK - Tentative de Commit...");
                        transaction.Commit();
                        Log.Logger.Debug("Commit OK");
                    }
                    catch (Exception ex)
                    {
                        Log.Logger.Debug(ex);
                        Log.Logger.Debug("Tentative de Rollback...");
                        transaction.Rollback();
                        Log.Logger.Debug("Rollback OK");
                        throw;
                    }
                }
            }
            Log.Logger.Debug("Fin Update");
            return o;
        }
        /// <summary>
        /// Supprime l'Operation passée en paramétre
        /// </summary>
        /// <param name="o">L'Operation à supprimer</param>
        public static void Delete(Operation o)
        {
            Log.Logger.Debug("Debut Delete");
            using (var session = NHibernateHelper.OpenSession())
            {
                using (var transaction = session.BeginTransaction())
                {
                    try
                    {
                        Log.Logger.Debug("Tentative de Delete...");
                        session.Delete(o);
                        Log.Logger.Debug("Delete OK - Tentative de Commit...");
                        transaction.Commit();
                        Log.Logger.Debug("Commit OK");
                    }
                    catch (Exception ex)
                    {
                        Log.Logger.Debug(ex);
                        Log.Logger.Debug("Tentative de Rollback...");
                        transaction.Rollback();
                        Log.Logger.Debug("Rollback OK");
                        throw;
                    }
                }
            }
            Log.Logger.Debug("Delete Fin");
        }
    }
    #endregion

    #region ChequeRepository
    /// <summary>
    /// Classe permettant de gérer l'accès aux données de la table Cheques
    /// </summary>
    public class ChequeRepository
    {
        /// <summary>
        /// Retrouve un Cheque d'après son Id
        /// </summary>
        /// <param name="id">Identifiant unique du Cheque</param>
        /// <returns>Cheque</returns>
        public static Cheque GetById(int id)
        {
            Log.Logger.Debug("Debut GetById:" + id);
            Log.Logger.Info("Initialisation du Cheque");
            Cheque c = new Cheque();
            using (var session = NHibernateHelper.OpenSession())
            {
                Log.Logger.Info("Récupération du Cheque");
                c = (from cheque in session.Query<Cheque>()
                     where cheque.Id == id
                     select cheque).Single();
            }
            Log.Logger.Debug("Fin BetById");
            return c;
        }
        /// <summary>
        /// Ajoute le Cheque passé en paramétre
        /// </summary>
        /// <param name="c">Le Cheque à créer</param>
        /// <returns>Le Cheque créé</returns>
        public static Cheque Add(Cheque c)
        {
            Log.Logger.Debug("Debut Add");
            using (var session = NHibernateHelper.OpenSession())
            {
                using (var transaction = session.BeginTransaction())
                {
                    Log.Logger.Info("Tentative de Save");
                    try
                    {
                        Log.Logger.Info("Save OK - Tentative de Commit");
                        session.Save(c);
                        Log.Logger.Info("Save OK - Tentative de Commit");
                        transaction.Commit();
                        Log.Logger.Info("Commit OK");
                    }
                    catch (Exception ex)
                    {
                        Log.Logger.Error(ex);
                        Log.Logger.Info("Tentative de Rollback...");
                        transaction.Rollback();
                        Log.Logger.Info("Rollback OK");
                        throw;
                    }
                }
            }
            Log.Logger.Debug("Fin Add");
            return c;
        }
        /// <summary>
        /// Met à jour le Cheque passé en paramétre
        /// </summary>
        /// <param name="c">Le Cheque à mettre à jour</param>
        /// <returns>Le Cheque mis à jour</returns>
        public static Cheque Update(Cheque c)
        {
            Log.Logger.Debug("Debut Update");
            using (var session = NHibernateHelper.OpenSession())
            {
                using (var transaction = session.BeginTransaction())
                {
                    try
                    {
                        Log.Logger.Debug("Tentative d'Update...");
                        session.Update(c);
                        Log.Logger.Debug("Update OK - Tentative de Commit...");
                        transaction.Commit();
                        Log.Logger.Debug("Commit OK");
                    }
                    catch (Exception ex)
                    {
                        Log.Logger.Debug(ex);
                        Log.Logger.Debug("Tentative de Rollback...");
                        transaction.Rollback();
                        Log.Logger.Debug("Rollback OK");
                        throw;
                    }
                }
            }
            Log.Logger.Debug("Fin Update");
            return c;
        }
        /// <summary>
        /// Supprime le Cheque passé en paramétre
        /// </summary>
        /// <param name="o">Le Cheque à supprimer</param>
        public static void Delete(Cheque c)
        {
            Log.Logger.Debug("Debut Delete");
            using (var session = NHibernateHelper.OpenSession())
            {
                using (var transaction = session.BeginTransaction())
                {
                    try
                    {
                        Log.Logger.Debug("Tentative de Delete...");
                        session.Delete(c);
                        Log.Logger.Debug("Delete OK - Tentative de Commit...");
                        transaction.Commit();
                        Log.Logger.Debug("Commit OK");
                    }
                    catch (Exception ex)
                    {
                        Log.Logger.Debug(ex);
                        Log.Logger.Debug("Tentative de Rollback...");
                        transaction.Rollback();
                        Log.Logger.Debug("Rollback OK");
                        throw;
                    }
                }
            }
            Log.Logger.Debug("Delete Fin");
        }
    }
    #endregion

    #region EcheancierRepository
    /// <summary>
    /// Classe permettant de gérer l'accès aux données de la table Echeanciers
    /// </summary>
    public class EcheancierRepository
    {
        /// <summary>
        /// Retrouve une Operation d'après son Id
        /// </summary>
        /// <param name="id">Identifiant unique de l'Echeancier</param>
        /// <returns>Echeancier</returns>
        public static Echeancier GetById(int id)
        {
            Log.Logger.Debug("Debut GetById:" + id);
            Log.Logger.Info("Initialisation de l'Echeancier");
            Echeancier e = new Echeancier();
            using (var session = NHibernateHelper.OpenSession())
            {
                Log.Logger.Info("Récupération de l'Echeancier");
                e = (from echeancier in session.Query<Echeancier>()
                     where echeancier.Id == id
                     select echeancier).Single();
            }
            Log.Logger.Debug("Fin BetById");
            return e;
        }
        /// <summary>
        /// Ajoute l'Echeancier passé en paramétre
        /// </summary>
        /// <param name="e">L'Echeancier à créer</param>
        /// <returns>L'Echeancier créé</returns>
        public static Echeancier Add(Echeancier e)
        {
            Log.Logger.Debug("Debut Add");
            using (var session = NHibernateHelper.OpenSession())
            {
                using (var transaction = session.BeginTransaction())
                {
                    Log.Logger.Info("Tentative de Save");
                    try
                    {
                        Log.Logger.Info("Save OK - Tentative de Commit");
                        session.Save(e);
                        Log.Logger.Info("Save OK - Tentative de Commit");
                        transaction.Commit();
                        Log.Logger.Info("Commit OK");
                    }
                    catch (Exception ex)
                    {
                        Log.Logger.Error(ex);
                        Log.Logger.Info("Tentative de Rollback...");
                        transaction.Rollback();
                        Log.Logger.Info("Rollback OK");
                        throw;
                    }
                }
            }
            Log.Logger.Debug("Fin Add");
            return e;
        }
        /// <summary>
        /// Met à jour l'Echeancier passé en paramétre
        /// </summary>
        /// <param name="e">L'Echeancier à mettre à jour</param>
        /// <returns>L'Echeancier mis à jour</returns>
        public static Echeancier Update(Echeancier e)
        {
            Log.Logger.Debug("Debut Update");
            using (var session = NHibernateHelper.OpenSession())
            {
                using (var transaction = session.BeginTransaction())
                {
                    try
                    {
                        Log.Logger.Debug("Tentative d'Update...");
                        session.Update(e);
                        Log.Logger.Debug("Update OK - Tentative de Commit...");
                        transaction.Commit();
                        Log.Logger.Debug("Commit OK");
                    }
                    catch (Exception ex)
                    {
                        Log.Logger.Debug(ex);
                        Log.Logger.Debug("Tentative de Rollback...");
                        transaction.Rollback();
                        Log.Logger.Debug("Rollback OK");
                        throw;
                    }
                }
            }
            Log.Logger.Debug("Fin Update");
            return e;
        }
        /// <summary>
        /// Supprime l'Echeancier passé en paramétre
        /// </summary>
        /// <param name="e">L'Echeancier à supprimer</param>
        public static void Delete(Echeancier e)
        {
            Log.Logger.Debug("Debut Delete");
            using (var session = NHibernateHelper.OpenSession())
            {
                using (var transaction = session.BeginTransaction())
                {
                    try
                    {
                        Log.Logger.Debug("Tentative de Delete...");
                        session.Delete(e);
                        Log.Logger.Debug("Delete OK - Tentative de Commit...");
                        transaction.Commit();
                        Log.Logger.Debug("Commit OK");
                    }
                    catch (Exception ex)
                    {
                        Log.Logger.Debug(ex);
                        Log.Logger.Debug("Tentative de Rollback...");
                        transaction.Rollback();
                        Log.Logger.Debug("Rollback OK");
                        throw;
                    }
                }
            }
            Log.Logger.Debug("Delete Fin");
        }
    }
    #endregion

    #region LienRepository
    /// <summary>
    /// Classe permettant de gérer l'accès aux données de la table Liens
    /// </summary>
    public class LienRepository
    {
        /// <summary>
        /// Retrouve un Lien d'après son Id
        /// </summary>
        /// <param name="id">Identifiant unique du Lien</param>
        /// <returns>Lien</returns>
        public static Lien GetById(int id)
        {
            Log.Logger.Debug("Debut GetById:" + id);
            Log.Logger.Info("Initialisation du Lien");
            Lien l = new Lien();
            using (var session = NHibernateHelper.OpenSession())
            {
                Log.Logger.Info("Récupération du Lien");
                l = (from lien in session.Query<Lien>()
                     where lien.Id == id
                     select lien).Single();
            }
            Log.Logger.Debug("Fin BetById");
            return l;
        }
        /// <summary>
        /// Ajoute du Lien passé en paramétre
        /// </summary>
        /// <param name="l">Lien à créer</param>
        /// <returns>Lien créé</returns>
        public static Lien Add(Lien l)
        {
            Log.Logger.Debug("Debut Add");
            using (var session = NHibernateHelper.OpenSession())
            {
                using (var transaction = session.BeginTransaction())
                {
                    Log.Logger.Info("Tentative de Save");
                    try
                    {
                        Log.Logger.Info("Save OK - Tentative de Commit");
                        session.Save(l);
                        Log.Logger.Info("Save OK - Tentative de Commit");
                        transaction.Commit();
                        Log.Logger.Info("Commit OK");
                    }
                    catch (Exception ex)
                    {
                        Log.Logger.Error(ex);
                        Log.Logger.Info("Tentative de Rollback...");
                        transaction.Rollback();
                        Log.Logger.Info("Rollback OK");
                        throw;
                    }
                }
            }
            Log.Logger.Debug("Fin Add");
            return l;
        }
        /// <summary>
        /// Met à jour le Lien passé en paramétre
        /// </summary>
        /// <param name="l">Le Lien à mettre à jour</param>
        /// <returns>Le Lien mis à jour</returns>
        public static Lien Update(Lien l)
        {
            Log.Logger.Debug("Debut Update");
            using (var session = NHibernateHelper.OpenSession())
            {
                using (var transaction = session.BeginTransaction())
                {
                    try
                    {
                        Log.Logger.Debug("Tentative d'Update...");
                        session.Update(l);
                        Log.Logger.Debug("Update OK - Tentative de Commit...");
                        transaction.Commit();
                        Log.Logger.Debug("Commit OK");
                    }
                    catch (Exception ex)
                    {
                        Log.Logger.Debug(ex);
                        Log.Logger.Debug("Tentative de Rollback...");
                        transaction.Rollback();
                        Log.Logger.Debug("Rollback OK");
                        throw;
                    }
                }
            }
            Log.Logger.Debug("Fin Update");
            return l;
        }
        /// <summary>
        /// Supprime le Lien passé en paramétre
        /// </summary>
        /// <param name="l">Le Lien à supprimer</param>
        public static void Delete(Lien l)
        {
            Log.Logger.Debug("Debut Delete");
            using (var session = NHibernateHelper.OpenSession())
            {
                using (var transaction = session.BeginTransaction())
                {
                    try
                    {
                        Log.Logger.Debug("Tentative de Delete...");
                        session.Delete(l);
                        Log.Logger.Debug("Delete OK - Tentative de Commit...");
                        transaction.Commit();
                        Log.Logger.Debug("Commit OK");
                    }
                    catch (Exception ex)
                    {
                        Log.Logger.Debug(ex);
                        Log.Logger.Debug("Tentative de Rollback...");
                        transaction.Rollback();
                        Log.Logger.Debug("Rollback OK");
                        throw;
                    }
                }
            }
            Log.Logger.Debug("Delete Fin");
        }
    }
    #endregion
    
}
